/*
Copyright [2012] [Maria Eugenia Malagamba]
Copyright [2012] [Leandro Pellegrino]
Copyright [2012] [Julia Gambuzzi]
Copyright [2012] [Ignacio Capodanno]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/

#include "PestaniaCliente.h"

PestaniaCliente::PestaniaCliente(SDL_Surface* ventana): Pestania(ventana)
{
	this->fondo = SDL_LoadBMP("fondoCliente.bmp");
	this->partida = NULL;
	this->informacionDelCliente = new InformacionDelCliente();

	// text boxes
	this->textBoxHost = new TextBox( 130, 200, "localhost");
	this->textBoxPuerto = new TextBox( 130, 240, "8085");
	this->textBoxJugador = new TextBox( 130, 280, "luke", 6);

	// los guardo en un vector para facilitar la selección
	cajasDeTextoSeleccionables = new vector<TextBox*>();
	cajasDeTextoSeleccionables->push_back(textBoxHost);
	cajasDeTextoSeleccionables->push_back(textBoxPuerto);
	cajasDeTextoSeleccionables->push_back(textBoxJugador);

	// labels
	this->labelNave = new Label( 20, 40, "Nave:", 26);
	this->labelHost = new Label( 20, 200, "Host", 26);
	this->labelPuerto = new Label( 20, 240, "Puerto", 26);
	this->labelJugador = new Label( 20, 280, "Jugador", 26);
	this->estadoDelJugador = new Label( 10, 470, "Presione Conectar para conectarse al servidor                   ", 18);

	// botones
	this->botonSalir = new Boton( 20, 400, "Salir" ,"botonI");
	this->botonConectar = new Boton( 275, 400, "Conectar" ,"botonI");

	// imagenes
	imagenesDeLaNave = new vector<ImagenSeleccionable*>();
	imagenesDeLaNave->push_back(new ImagenSeleccionable(20, 80, "nave1.bmp", true));
	imagenesDeLaNave->push_back(new ImagenSeleccionable(100, 80, "nave2.bmp", false));
	imagenesDeLaNave->push_back(new ImagenSeleccionable(180, 80, "nave3.bmp", false));
	imagenesDeLaNave->push_back(new ImagenSeleccionable(260, 80, "nave4.bmp", false));
	imagenesDeLaNave->push_back(new ImagenSeleccionable(340, 80, "nave5.bmp", false));
}

int PestaniaCliente::actuar(SDL_Event evento){	

	if (evento.type != SDL_KEYDOWN){

		bool cambioLaSeleccionDeImagen = this->actualizarSeleccion((vector<ControlSeleccionable*>*)this->imagenesDeLaNave, evento); 

		// si cambió la selección de imagen fue porque clickearon una imagen 
		// no es necesario chequear el textbox
		if (!cambioLaSeleccionDeImagen){
			this->actualizarSeleccion((vector<ControlSeleccionable*>*)this->cajasDeTextoSeleccionables, evento);
		}
		if(this->botonConectar->fuiClickeado(evento.button.x,evento.button.y)){
			if(this->unirClienteAPartida()== 8){
				if(this->partida != NULL){
					delete this->partida;
					this->partida = NULL;
				}
			}
		}

		if(this->botonSalir->fuiClickeado(evento.button.x,evento.button.y)){
			if(this->partida != NULL){
				delete this->partida;
				this->partida = NULL;
			}
			return -1;
		}
	}else{
		// obtengo el textBox activo, si hay
		TextBox* textBoxActivo = NULL;
		for (unsigned int i = 0; i < this->cajasDeTextoSeleccionables->size(); i++){
			if (this->cajasDeTextoSeleccionables->at(i)->getSeleccionada()){
				textBoxActivo = this->cajasDeTextoSeleccionables->at(i);
				break;
			}
		}

		if (textBoxActivo != NULL && textBoxActivo->ingreso(evento)){
			textBoxActivo->mostrar(this->ventana);
		}
	}

	return 1;
}

// Busco que control fue seleccionado, deseleccionando y seleccionando uno nuevo si es necesario.
// Retorna true si cambió la selección
bool PestaniaCliente::actualizarSeleccion(vector<ControlSeleccionable*>* controles, SDL_Event evento){

	int x = evento.button.x;
	int y = evento.button.y;
	bool cambioLaSeleccion = false;

	for(unsigned int i = 0; i < controles->size(); i++){
		ControlSeleccionable *controlActual = controles->at(i);
		cambioLaSeleccion = controlActual->fuiClickeado(x,y) && controlActual->getSeleccionada() == false;

		if (cambioLaSeleccion){
			// deselecciono a la que estaba seleccionada
			for(unsigned int j = 0; j < controles->size(); j++){
				if (controles->at(j)->getSeleccionada()){
					controles->at(j)->setSeleccionada(false);
					controles->at(j)->mostrar(this->ventana);
					break;
				}
			}
			controlActual->setSeleccionada(controlActual->fuiClickeado(x,y));
			controlActual->mostrar(this->ventana);
			break;
		}
	}

	return cambioLaSeleccion;
}

void PestaniaCliente::mostrar(SDL_Surface* ventana){
	SDL_Rect posicion;
	posicion.x = 0;
	posicion.y = 40;
	SDL_BlitSurface(this->fondo,NULL,ventana,&posicion);

	// text boxes
	this->textBoxHost->mostrar(ventana);
	this->textBoxPuerto->mostrar(ventana);
	this->textBoxJugador->mostrar(ventana);

	// labels
	this->labelHost->mostrar(ventana);
	this->labelPuerto->mostrar(ventana);
	this->labelJugador->mostrar(ventana);
	this->labelNave->mostrar(ventana);
	this->estadoDelJugador->mostrar(ventana);

	// botones
	this->botonSalir->mostrar(ventana);
	this->botonConectar->mostrar(ventana);

	// imagenes
	for(unsigned int i = 0; i < this->imagenesDeLaNave->size(); i++){
		this->imagenesDeLaNave->at(i)->mostrar(ventana);
	}
}

int PestaniaCliente::actuar(){

	if(this->partida != NULL){
		//Si ya hay dos clientes conectados, tienen que recibir del servidor la confirmacion
		int naveOtroCliente = -1;
		int numeroJugador = -1;
		string nombreOtroCliente = "";
		this->cambiarEstado("Esperando contrincante  . . .                                     ");
		naveOtroCliente = this->partida->cliente->recibirEntero();
		numeroJugador = this->partida->cliente->recibirEntero();
		nombreOtroCliente = this->partida->cliente->recibirString();
		if(naveOtroCliente != -1 && numeroJugador != -1){
			//iniciar el juego, debe recibir las cosas del cliente
			this->cambiarEstado("Comenzando el juego . . .                                     ");
			this->partida->iniciar(naveOtroCliente,numeroJugador,nombreOtroCliente);

			//cuando vuelve el juego, borro la partida
			if(this->partida != NULL){
				cambiarLabel();
				delete this->partida;
				this->partida = NULL;
				//7 es que inicio y termino
				//Borro carpeta Archivos Recibidos del cliente.
				borrarCarpetaTemporalArchivosRecibidos(this->informacionDelCliente->getJugador());
				return 7;
			}
		}
	}

	return 0;
}

int PestaniaCliente::unirClienteAPartida(){

	// obtenemos la informacion
	this->informacionDelCliente->setHost(this->textBoxHost->getValor());
	this->informacionDelCliente->setPuerto(this->textBoxPuerto->getValor());
	this->informacionDelCliente->setJugador(this->textBoxJugador->getValor());
	for (unsigned int i = 0; i < this->imagenesDeLaNave->size(); i++){
		if (this->imagenesDeLaNave->at(i)->getSeleccionada()){
			this->informacionDelCliente->setNumeroDeNave(i);
			break;
		}
	}

	// unimos el cliente a la partida

	this->cambiarEstado("Conectando con el servidor . . .                                                ");
	this->partida = new PartidaCliente(this->informacionDelCliente->getNumeroDeNave());
	if(partida->unirseAPartida(this->informacionDelCliente->getPuerto(),this->informacionDelCliente->getHost()) == 0){
		this->cambiarEstado("Recibiendo escenario del servidor . . .                                     ");
		partida->recibirEscenario(this->informacionDelCliente->getJugador());
	}else{
		this->cambiarEstado("No se pudo establecer la conexion o la partida esta completa                 ");
		return 8;
	}
	return 0;
}

void PestaniaCliente::cambiarEstado(string nuevoEstado){

	this->estadoDelJugador->cambiarTexto(nuevoEstado);
	SDL_FillRect( this->ventana, &this->estadoDelJugador->posicion, SDL_MapRGB( this->ventana->format, 0, 173,92 ) );
	this->estadoDelJugador->mostrar(this->ventana);
	SDL_Flip(this->ventana);

}

void PestaniaCliente::borrarCarpetaTemporalArchivosRecibidos(string nombreCliente){

	WIN32_FIND_DATA datosArchivosEncontrados;
	HANDLE handlerBuscador = INVALID_HANDLE_VALUE;
	wstring carpetaTemporal = L".\\ArchivosRecibidos - ";

	wstring temp(nombreCliente.length(),L' ');
	copy(nombreCliente.begin(), nombreCliente.end(), temp.begin());
	wstring pathArchivo = L".\\ArchivosRecibidos - "+temp+L"\\*.*";
	wstring nombreArchivo;

	handlerBuscador = FindFirstFile( pathArchivo.c_str(), &datosArchivosEncontrados);
	while (FindNextFile(handlerBuscador, &datosArchivosEncontrados) != 0)
	{
		nombreArchivo = datosArchivosEncontrados.cFileName; 
		wstring archivo = L".\\ArchivosRecibidos - " + temp + L"\\" + nombreArchivo;
		//Borro cada archivo de la carpeta temporal archivos recibidos.
		DeleteFileW(archivo.c_str());
	}
	FindClose(handlerBuscador);

	//Borro la carpeta temporal archivos recibidos.
	string pathCarpetaCliente = ".\\ArchivosRecibidos - "+nombreCliente;
	RemoveDirectoryA(pathCarpetaCliente.c_str());
}

void PestaniaCliente::cambiarLabel(){
	if(this->partida->getResultadoPartida() == GAME_OVER){
		this->cambiarEstado("  ***** GAME OVER *****                                               ");
	}else if(this->partida->getResultadoPartida() == WIN){
		this->cambiarEstado("  ***** YOU WIN!!!!!! *****                                           ");	
	}else{
		this->cambiarEstado("Presione Conectar para conectarse al servidor                         ");
	}
}

PestaniaCliente::~PestaniaCliente()
{
	// borro las cajas de texto
	for(unsigned int i = 0; i < cajasDeTextoSeleccionables->size(); i++){
		delete (cajasDeTextoSeleccionables->at(i));
	}
	delete cajasDeTextoSeleccionables;
	
	// borro los labels
	delete this->labelNave;
	delete this->labelHost;
	delete this->labelPuerto;
	delete this->labelJugador;
	delete this->estadoDelJugador;

	// borro los botones
	delete this->botonSalir;
	delete this->botonConectar;

	// borro las imagenes
	for(unsigned int i = 0; i < imagenesDeLaNave->size(); i++){
		delete (imagenesDeLaNave->at(i));
	}
	delete imagenesDeLaNave; 

	// otros
	delete this->informacionDelCliente;
	if (this->partida != NULL) delete this->partida;
	SDL_FreeSurface(this->fondo);
}
